github.com/refraction-networking/utls.Conn.config (field)

222 uses

	github.com/refraction-networking/utls (current package)
		conn.go#L43: 	config         *Config // configuration passed to constructor
		conn.go#L897: 	if c.config.DynamicRecordSizingDisabled || typ != recordTypeApplicationData {
		conn.go#L1026: 		outBuf, err = c.out.encrypt(outBuf, data[:m], c.config.rand())
		conn.go#L1283: 	switch c.config.Renegotiation {
		conn.go#L1653: 	if c.config.Renegotiation != RenegotiateNever {
		ech.go#L575: 	if len(c.config.EncryptedClientHelloKeys) == 0 {
		ech.go#L579: 	for _, echKey := range c.config.EncryptedClientHelloKeys {
		handshake_client.go#L49: 	config := c.config
		handshake_client.go#L214: 	if c.config.EncryptedClientHelloConfigList != nil {
		handshake_client.go#L215: 		if c.config.MinVersion != 0 && c.config.MinVersion < VersionTLS13 {
		handshake_client.go#L218: 		if c.config.MaxVersion != 0 && c.config.MaxVersion <= VersionTLS12 {
		handshake_client.go#L221: 		echConfigs, err := parseECHConfigList(c.config.EncryptedClientHelloConfigList)
		handshake_client.go#L271: 	if c.config == nil {
		handshake_client.go#L272: 		c.config = defaultConfig()
		handshake_client.go#L298: 					c.config.ClientSessionCache.Put(cacheKey, nil)
		handshake_client.go#L313: 		_, err = io.ReadFull(c.config.rand(), hello.random)
		handshake_client.go#L362: 	maxVers := c.config.maxSupportedVersion(roleClient)
		handshake_client.go#L404: 	if c.config.SessionTicketsDisabled || c.config.ClientSessionCache == nil {
		handshake_client.go#L432: 	cs, ok := c.config.ClientSessionCache.Get(cacheKey)
		handshake_client.go#L454: 	if !c.config.InsecureSkipTimeVerify {
		handshake_client.go#L455: 		if c.config.time().After(session.peerCertificates[0].NotAfter) {
		handshake_client.go#L457: 			c.config.ClientSessionCache.Put(cacheKey, nil)
		handshake_client.go#L462: 	if !c.config.InsecureSkipVerify {
		handshake_client.go#L469: 		if len(c.config.InsecureServerNameToVerify) == 0 {
		handshake_client.go#L470: 			dnsName = c.config.ServerName
		handshake_client.go#L471: 		} else if c.config.InsecureServerNameToVerify != "*" {
		handshake_client.go#L472: 			dnsName = c.config.InsecureServerNameToVerify
		handshake_client.go#L494: 	if c.config.time().After(time.Unix(int64(session.useBy), 0)) {
		handshake_client.go#L495: 		c.config.ClientSessionCache.Put(cacheKey, nil)
		handshake_client.go#L535: 	ticketAge := c.config.time().Sub(time.Unix(int64(session.createdAt), 0))
		handshake_client.go#L565: 	vers, ok := c.config.mutualVersion(roleClient, []uint16{peerVersion})
		handshake_client.go#L595: 	if isResume || (len(c.config.Certificates) == 0 && c.config.GetClientCertificate == nil) {
		handshake_client.go#L622: 		if c.config.VerifyConnection != nil {
		handshake_client.go#L623: 			if err := c.config.VerifyConnection(c.connectionStateLocked()); err != nil {
		handshake_client.go#L749: 		err = keyAgreement.processServerKeyExchange(c.config, hs.hello, hs.serverHello, c.peerCertificates[0], skx)
		handshake_client.go#L799: 	preMasterSecret, ckx, err := keyAgreement.generateClientKeyExchange(c.config, hs.hello, c.peerCertificates[0])
		handshake_client.go#L818: 	if err := c.config.writeKeyLog(keyLogLabelTLS12, hs.hello.random, hs.masterSecret); err != nil {
		handshake_client.go#L859: 		certVerify.signature, err = key.Sign(c.config.rand(), signed, signOpts)
		handshake_client.go#L1076: 	if c.config.ClientSessionCache != nil { // skip saving session if cache is nil
		handshake_client.go#L1077: 		c.config.ClientSessionCache.Put(cacheKey, cs)
		handshake_client.go#L1142: 	echRejected := c.config.EncryptedClientHelloConfigList != nil && !c.echAccepted
		handshake_client.go#L1144: 		if c.config.EncryptedClientHelloRejectionVerify != nil {
		handshake_client.go#L1145: 			if err := c.config.EncryptedClientHelloRejectionVerify(c.connectionStateLocked()); err != nil {
		handshake_client.go#L1151: 				Roots:       c.config.RootCAs,
		handshake_client.go#L1152: 				CurrentTime: c.config.time(),
		handshake_client.go#L1158: 			if c.config.InsecureSkipTimeVerify {
		handshake_client.go#L1162: 			if len(c.config.InsecureServerNameToVerify) == 0 {
		handshake_client.go#L1163: 				opts.DNSName = c.config.ServerName
		handshake_client.go#L1164: 			} else if c.config.InsecureServerNameToVerify != "*" {
		handshake_client.go#L1165: 				opts.DNSName = c.config.InsecureServerNameToVerify
		handshake_client.go#L1184: 	} else if !c.config.InsecureSkipVerify {
		handshake_client.go#L1187: 			Roots:       c.config.RootCAs,
		handshake_client.go#L1188: 			CurrentTime: c.config.time(),
		handshake_client.go#L1193: 		if c.config.InsecureSkipTimeVerify {
		handshake_client.go#L1197: 		if len(c.config.InsecureServerNameToVerify) == 0 {
		handshake_client.go#L1198: 			opts.DNSName = c.config.ServerName
		handshake_client.go#L1199: 		} else if c.config.InsecureServerNameToVerify != "*" {
		handshake_client.go#L1200: 			opts.DNSName = c.config.InsecureServerNameToVerify
		handshake_client.go#L1231: 	if c.config.VerifyPeerCertificate != nil && !echRejected {
		handshake_client.go#L1232: 		if err := c.config.VerifyPeerCertificate(certificates, c.verifiedChains); err != nil {
		handshake_client.go#L1238: 	if c.config.VerifyConnection != nil && !echRejected {
		handshake_client.go#L1239: 		if err := c.config.VerifyConnection(c.connectionStateLocked()); err != nil {
		handshake_client.go#L1315: 	if c.config.GetClientCertificate != nil {
		handshake_client.go#L1316: 		return c.config.GetClientCertificate(cri)
		handshake_client.go#L1319: 	for _, chain := range c.config.Certificates {
		handshake_client.go#L1333: 	if len(c.config.ServerName) > 0 {
		handshake_client.go#L1334: 		return c.config.ServerName
		handshake_client_tls13.go#L114: 			c.serverName = c.config.ServerName
		handshake_client_tls13.go#L293: 				c.serverName = c.config.ServerName
		handshake_client_tls13.go#L348: 		key, err := generateECDHEKey(c.config.rand(), curveID)
		handshake_client_tls13.go#L364: 			ticketAge := c.config.time().Sub(time.Unix(int64(hs.session.createdAt), 0))
		handshake_client_tls13.go#L669: 	err = c.config.writeKeyLog(keyLogLabelClientHandshake, hs.hello.random, clientSecret)
		handshake_client_tls13.go#L674: 	err = c.config.writeKeyLog(keyLogLabelServerHandshake, hs.hello.random, serverSecret)
		handshake_client_tls13.go#L771: 		if c.config.VerifyConnection != nil {
		handshake_client_tls13.go#L772: 			if err := c.config.VerifyConnection(c.connectionStateLocked()); err != nil {
		handshake_client_tls13.go#L912: 	err = c.config.writeKeyLog(keyLogLabelClientTraffic, hs.hello.random, hs.trafficSecret)
		handshake_client_tls13.go#L917: 	err = c.config.writeKeyLog(keyLogLabelServerTraffic, hs.hello.random, serverSecret)
		handshake_client_tls13.go#L988: 	sig, err := cert.PrivateKey.(crypto.Signer).Sign(c.config.rand(), signed, signOpts)
		handshake_client_tls13.go#L1015: 	if !c.config.SessionTicketsDisabled && c.config.ClientSessionCache != nil {
		handshake_client_tls13.go#L1035: 	if c.config.SessionTicketsDisabled || c.config.ClientSessionCache == nil {
		handshake_client_tls13.go#L1065: 	session.useBy = uint64(c.config.time().Add(lifetime).Unix())
		handshake_client_tls13.go#L1075: 		c.config.ClientSessionCache.Put(cacheKey, cs)
		handshake_server.go#L160: 	originalConfig := c.config
		handshake_server.go#L161: 	if c.config.GetConfigForClient != nil {
		handshake_server.go#L163: 		if configForClient, err = c.config.GetConfigForClient(chi); err != nil {
		handshake_server.go#L167: 			c.config = configForClient
		handshake_server.go#L176: 	c.vers, ok = c.config.mutualVersion(roleServer, clientVersions)
		handshake_server.go#L231: 	maxVers := c.config.maxSupportedVersion(roleServer)
		handshake_server.go#L240: 	_, err := io.ReadFull(c.config.rand(), serverRandom)
		handshake_server.go#L258: 	selectedProto, err := negotiateALPN(c.config.NextProtos, hs.clientHello.alpnProtocols, false)
		handshake_server.go#L266: 	hs.cert, err = c.config.getCertificate(clientHelloInfo(hs.ctx, c, hs.clientHello))
		handshake_server.go#L279: 	hs.ecdheOk = supportsECDHE(c.config, c.vers, hs.clientHello.supportedCurves, hs.clientHello.supportedPoints)
		handshake_server.go#L385: 	configCipherSuites := c.config.cipherSuites()
		handshake_server.go#L418: 			if hs.clientHello.vers < c.config.maxSupportedVersion(roleServer) {
		handshake_server.go#L454: 	if c.config.SessionTicketsDisabled {
		handshake_server.go#L459: 	if c.config.UnwrapSession != nil {
		handshake_server.go#L460: 		ss, err := c.config.UnwrapSession(hs.clientHello.sessionTicket, c.connectionStateLocked())
		handshake_server.go#L469: 		plaintext := c.config.decryptTicket(hs.clientHello.sessionTicket, c.ticketKeys)
		handshake_server.go#L484: 	if c.config.time().Sub(createdAt) > maxSessionTicketLifetime {
		handshake_server.go#L507: 		c.config.cipherSuites(), hs.cipherSuiteOk)
		handshake_server.go#L513: 	needClientCerts := requiresClientCert(c.config.ClientAuth)
		handshake_server.go#L517: 	if sessionHasClientCerts && c.config.ClientAuth == NoClientCert {
		handshake_server.go#L520: 	if sessionHasClientCerts && c.config.time().After(sessionState.peerCertificates[0].NotAfter) {
		handshake_server.go#L523: 	if sessionHasClientCerts && c.config.ClientAuth >= VerifyClientCertIfGiven &&
		handshake_server.go#L570: 	if c.config.VerifyConnection != nil {
		handshake_server.go#L571: 		if err := c.config.VerifyConnection(c.connectionStateLocked()); err != nil {
		handshake_server.go#L589: 	hs.hello.ticketSupported = hs.clientHello.ticketSupported && !c.config.SessionTicketsDisabled
		handshake_server.go#L593: 	if c.config.ClientAuth == NoClientCert {
		handshake_server.go#L620: 	skx, err := keyAgreement.generateServerKeyExchange(c.config, hs.cert, hs.clientHello, hs.hello)
		handshake_server.go#L635: 	if c.config.ClientAuth >= RequestClientCert {
		handshake_server.go#L652: 		if c.config.ClientCAs != nil {
		handshake_server.go#L653: 			certReq.certificateAuthorities = c.config.ClientCAs.Subjects()
		handshake_server.go#L678: 	if c.config.ClientAuth >= RequestClientCert {
		handshake_server.go#L699: 	if c.config.VerifyConnection != nil {
		handshake_server.go#L700: 		if err := c.config.VerifyConnection(c.connectionStateLocked()); err != nil {
		handshake_server.go#L713: 	preMasterSecret, err := keyAgreement.processClientKeyExchange(c.config, hs.cert, ckx, c.vers)
		handshake_server.go#L726: 	if err := c.config.writeKeyLog(keyLogLabelTLS12, hs.clientHello.random, hs.masterSecret); err != nil {
		handshake_server.go#L864: 	if c.config.WrapSession != nil {
		handshake_server.go#L866: 		m.ticket, err = c.config.WrapSession(c.connectionStateLocked(), state)
		handshake_server.go#L875: 		m.ticket, err = c.config.encryptTicket(stateBytes, c.ticketKeys)
		handshake_server.go#L926: 	if len(certs) == 0 && requiresClientCert(c.config.ClientAuth) {
		handshake_server.go#L935: 	if c.config.ClientAuth >= VerifyClientCertIfGiven && len(certs) > 0 {
		handshake_server.go#L937: 			Roots:         c.config.ClientCAs,
		handshake_server.go#L938: 			CurrentTime:   c.config.time(),
		handshake_server.go#L980: 	if c.config.VerifyPeerCertificate != nil {
		handshake_server.go#L981: 		if err := c.config.VerifyPeerCertificate(certificates, c.verifiedChains); err != nil {
		handshake_server.go#L1006: 		config:            c.config,
		handshake_server_tls13.go#L135: 			if c.vers < c.config.maxSupportedVersion(roleServer) {
		handshake_server_tls13.go#L150: 	if _, err := io.ReadFull(c.config.rand(), hs.hello.random); err != nil {
		handshake_server_tls13.go#L208: 	preferredGroups := c.config.curvePreferences(c.vers)
		handshake_server_tls13.go#L262: 	key, err := generateECDHEKey(c.config.rand(), ecdhGroup)
		handshake_server_tls13.go#L298: 	selectedProto, err := negotiateALPN(c.config.NextProtos, hs.clientHello.alpnProtocols, c.quic != nil)
		handshake_server_tls13.go#L333: 	if c.config.SessionTicketsDisabled {
		handshake_server_tls13.go#L362: 		if c.config.UnwrapSession != nil {
		handshake_server_tls13.go#L364: 			sessionState, err = c.config.UnwrapSession(identity.label, c.connectionStateLocked())
		handshake_server_tls13.go#L372: 			plaintext := c.config.decryptTicket(identity.label, c.ticketKeys)
		handshake_server_tls13.go#L388: 		if c.config.time().Sub(createdAt) > maxSessionTicketLifetime {
		handshake_server_tls13.go#L401: 		needClientCerts := requiresClientCert(c.config.ClientAuth)
		handshake_server_tls13.go#L405: 		if sessionHasClientCerts && c.config.ClientAuth == NoClientCert {
		handshake_server_tls13.go#L408: 		if sessionHasClientCerts && c.config.time().After(sessionState.peerCertificates[0].NotAfter) {
		handshake_server_tls13.go#L411: 		if sessionHasClientCerts && c.config.ClientAuth >= VerifyClientCertIfGiven &&
		handshake_server_tls13.go#L511: 	certificate, err := c.config.getCertificate(clientHelloInfo(hs.ctx, c, hs.clientHello))
		handshake_server_tls13.go#L779: 	err := c.config.writeKeyLog(keyLogLabelClientHandshake, hs.clientHello.random, clientSecret)
		handshake_server_tls13.go#L784: 	err = c.config.writeKeyLog(keyLogLabelServerHandshake, hs.clientHello.random, serverSecret)
		handshake_server_tls13.go#L804: 	if len(hs.c.config.EncryptedClientHelloKeys) > 0 && len(hs.clientHello.encryptedClientHello) > 0 && hs.echContext == nil {
		handshake_server_tls13.go#L805: 		encryptedExtensions.echRetryConfigs, err = buildRetryConfigList(hs.c.config.EncryptedClientHelloKeys)
		handshake_server_tls13.go#L820: 	return hs.c.config.ClientAuth >= RequestClientCert && !hs.usingPSK
		handshake_server_tls13.go#L837: 		if c.config.ClientCAs != nil {
		handshake_server_tls13.go#L838: 			certReq.certificateAuthorities = c.config.ClientCAs.Subjects()
		handshake_server_tls13.go#L870: 	sig, err := hs.cert.PrivateKey.(crypto.Signer).Sign(c.config.rand(), signed, signOpts)
		handshake_server_tls13.go#L917: 	err := c.config.writeKeyLog(keyLogLabelClientTraffic, hs.clientHello.random, hs.trafficSecret)
		handshake_server_tls13.go#L922: 	err = c.config.writeKeyLog(keyLogLabelServerTraffic, hs.clientHello.random, serverSecret)
		handshake_server_tls13.go#L943: 	if hs.c.config.SessionTicketsDisabled {
		handshake_server_tls13.go#L996: 	if c.config.WrapSession != nil {
		handshake_server_tls13.go#L998: 		m.label, err = c.config.WrapSession(c.connectionStateLocked(), state)
		handshake_server_tls13.go#L1008: 		m.label, err = c.config.encryptTicket(stateBytes, c.ticketKeys)
		handshake_server_tls13.go#L1019: 	if _, err := c.config.rand().Read(ageAdd); err != nil {
		handshake_server_tls13.go#L1042: 		if c.config.VerifyConnection != nil {
		handshake_server_tls13.go#L1043: 			if err := c.config.VerifyConnection(c.connectionStateLocked()); err != nil {
		handshake_server_tls13.go#L1069: 	if c.config.VerifyConnection != nil {
		handshake_server_tls13.go#L1070: 		if err := c.config.VerifyConnection(c.connectionStateLocked()); err != nil {
		quic.go#L208: 	if q.conn.config.MinVersion < VersionTLS13 {
		quic.go#L332: 	c.config.ClientSessionCache.Put(cacheKey, cs)
		ticket.go#L297: 		createdAt:         uint64(c.config.time().Unix()),
		tls.go#L37: 		config: config,
		tls.go#L50: 		config:   config,
		u_conn.go#L68: 	tlsConn := Conn{conn: conn, config: config, isClient: true}
		u_conn.go#L166: 	if cfg := uconn.config; cfg.SessionTicketsDisabled || cfg.ClientSessionCache == nil {
		u_conn.go#L226: 	if uconn.config.SessionTicketsDisabled || uconn.config.ClientSessionCache == nil {
		u_conn.go#L237: 	if uconn.config.SessionTicketsDisabled || uconn.config.ClientSessionCache == nil {
		u_conn.go#L250: 	uconn.config.ClientSessionCache = cache
		u_conn.go#L269: 	uconn.config.ServerName = hname
		u_conn.go#L568: 	if len(uconn.config.EncryptedClientHelloConfigList) > 0 {
		u_conn.go#L749: 	if uconn.config.EncryptedClientHelloConfigList == nil {
		u_conn.go#L750: 		uconn.config.MinVersion = minTLSVers
		u_conn.go#L751: 		uconn.config.MaxVersion = maxTLSVers
		u_conn.go#L768: 	tlsConn := &Conn{conn: tcpConn, config: &Config{}, isClient: isClient}
		u_conn.go#L925: 	switch c.config.Renegotiation {
		u_handshake_client.go#L158: 		if alps, ok := hs.uconn.config.ApplicationSettings[hs.serverHello.alpnProtocol]; ok {
		u_handshake_client.go#L171: 	config := c.config
		u_handshake_client.go#L337: 	if c.config.EncryptedClientHelloConfigList != nil {
		u_handshake_client.go#L338: 		if c.config.MinVersion != 0 && c.config.MinVersion < VersionTLS13 {
		u_handshake_client.go#L341: 		if c.config.MaxVersion != 0 && c.config.MaxVersion <= VersionTLS12 {
		u_handshake_client.go#L344: 		echConfigs, err := parseECHConfigList(c.config.EncryptedClientHelloConfigList)
		u_handshake_client.go#L395: 	if c.config == nil {
		u_handshake_client.go#L396: 		c.config = defaultConfig()
		u_handshake_client.go#L406: 	if len(c.config.ServerName) == 0 && !c.config.InsecureSkipVerify && len(c.config.InsecureServerNameToVerify) == 0 {
		u_handshake_client.go#L411: 	for _, proto := range c.config.NextProtos {
		u_handshake_client.go#L462: 					c.config.ClientSessionCache.Put(cacheKey, nil)
		u_handshake_client.go#L477: 		_, err = io.ReadFull(c.config.rand(), hello.random)
		u_handshake_client.go#L526: 	maxVers := c.config.maxSupportedVersion(roleClient)
		u_parrots.go#L2791: 		_, err := io.ReadFull(uconn.config.rand(), hello.Random)
		u_parrots.go#L2809: 	_, err = io.ReadFull(uconn.config.rand(), grease_bytes)
		u_parrots.go#L2835: 		_, err = io.ReadFull(uconn.config.rand(), sessionID[:])
		u_parrots.go#L2853: 				ext.ServerName = uconn.config.ServerName
		u_parrots.go#L2855: 			if uconn.config.EncryptedClientHelloConfigList != nil {
		u_parrots.go#L2888: 					ecdheKey, err := generateECDHEKey(uconn.config.rand(), X25519)
		u_parrots.go#L2893: 					if _, err := io.ReadFull(uconn.config.rand(), seed); err != nil {
		u_parrots.go#L2909: 					ecdheKey, err := generateECDHEKey(uconn.config.rand(), curveID)
		u_parrots.go#L2947: 	return generateRandomizedSpec(&uconn.ClientHelloID, uconn.serverName, uconn.config.NextProtos)
		u_pre_shared_key.go#L342: 	if uc.config.ClientSessionCache == nil {
		u_pre_shared_key.go#L345: 	if session, ok := uc.config.ClientSessionCache.Get(uc.clientSessionCacheKey()); !ok || session == nil {
		u_quic.go#L51: 	if q.conn.config.MinVersion < VersionTLS13 {
		u_session_controller.go#L293: 			s.pskExtension.SetOmitEmptyPsk(s.uconnRef.config.OmitEmptyPsk)
		u_tls_extensions.go#L202: 	if uc.config.EncryptedClientHelloConfigList == nil { // with ech, e.ServerName is the outer public name and should not be copied
		u_tls_extensions.go#L203: 		uc.config.ServerName = e.ServerName
		u_tls_extensions.go#L333: 	uc.config.CurvePreferences = e.Curves
		u_tls_extensions.go#L614: 	uc.config.NextProtos = e.AlpnProtocols
		u_tls_extensions.go#L1597: 	uc.config.NextProtos = e.NextProtos
		u_tls_extensions.go#L1687: 	uc.config.Renegotiation = e.Renegotiation

The pages are generated with Golds v0.8.4. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.